home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 0.9.1.3 stable / flock-0.9.1.3.en-US.win32.exe / flock / components / flockPollerService.js < prev    next >
Text File  |  2007-10-12  |  15KB  |  518 lines
  1. // BEGIN FLOCK GPL
  2. // 
  3. // Copyright Flock Inc. 2005-2007
  4. // http://flock.com
  5. // 
  6. // This file may be used under the terms of of the
  7. // GNU General Public License Version 2 or later (the "GPL"),
  8. // http://www.gnu.org/licenses/gpl.html
  9. // 
  10. // Software distributed under the License is distributed on an "AS IS" basis,
  11. // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12. // for the specific language governing rights and limitations under the
  13. // License.
  14. // 
  15. // END FLOCK GPL
  16. //
  17.  
  18. const PS_CONTRACTID = '@flock.com/poller-service;1';
  19. const PS_CLASSID    = Components.ID('{a2b4cd0e-804b-4578-8c3c-4b61f8c1047a}');
  20. const PS_CLASSNAME  = 'Flock Poller';
  21.  
  22.  
  23. const PREF_POLLER_BRANCH            = 'flock.poller'
  24. const PREF_REFRESH_DELAY            = '.refreshDelay';
  25. const PREF_REFRESH_TIMEOUT          = '.refreshTimeout';
  26. const PREF_DEFAULT_REFRESH_INTERVAL = '.defaultRefreshInterval';
  27. const PREF_MAX_CONCURRENT_REFRESHES = '.maxConcurrentRefreshes';
  28.  
  29. // According to Mozilla docs, timers can't be set for more than approximately
  30. // 6 hours. We'll limit to 4 hours just to be conservative.
  31. const MAX_TIMER_INTERVAL = 4 * 60 * 60 * 1000;
  32.  
  33.  
  34. const Ci = Components.interfaces;
  35. const Cc = Components.classes;
  36. const Cr = Components.results;
  37.  
  38.  
  39. function getObserverService() {
  40.   return Cc['@mozilla.org/observer-service;1']
  41.     .getService(Ci.nsIObserverService);
  42. } 
  43.  
  44.  
  45. function RefreshListener(poller, urn, serviceId) {
  46.   this._poller = poller;
  47.   this._urn = urn;
  48.   this._serviceId = serviceId;
  49. }
  50.  
  51. RefreshListener.prototype = {
  52.   onResult: function PSL_onResult() { 
  53.     this._poller._logger.info('Successful refresh for ' + this._urn);
  54.     this._poller._finishedRefresh(this._urn);
  55.   },
  56.   onError: function PSL_onError(error) {
  57.     this._poller._logger.error('The service ' + this._serviceId + ' returned an ' +
  58.                                'error while refreshing ' + this._urn);
  59.     this._poller._finishedRefresh(this._urn);
  60.   },
  61.   notify: function PSL_notify(timer) {
  62.     this._poller._logger.error('The service ' + this._serviceId + ' timed out ' +
  63.                                'while refreshing ' + this._urn);
  64.     this._poller._finishedRefresh(this._urn);
  65.   },
  66.   QueryInterface: function PSL_QueryInterface(iid) {
  67.     if (iid.equals(Ci.flockIPollerListener) ||
  68.         iid.equals(Ci.nsITimerCallback) ||
  69.         iid.equals(Ci.nsISupports))
  70.       return this;
  71.     throw Cr.NS_ERROR_NO_INTERFACE;
  72.   }
  73. }
  74.  
  75.  
  76. function PollerService() {
  77.   var obs = getObserverService();
  78.   obs.addObserver(this, 'flock-data-ready', false);
  79.   obs.addObserver(this, 'xpcom-shutdown', false);
  80. }
  81.  
  82. PollerService.prototype = {
  83.   _start: function PS__start() {
  84.     this._logger = Cc['@flock.com/logger;1'].createInstance(Ci.flockILogger);
  85.     this._logger.init('poller');
  86.     this._logger.info('starting up...');
  87.  
  88.     this._profiler = Cc["@flock.com/profiler;1"].getService(Ci.flockIProfiler);
  89.     var evtID = this._profiler.profileEventStart('poller-start');
  90.  
  91.     this._timer = Cc['@mozilla.org/timer;1'].createInstance(Ci.nsITimer);
  92.  
  93.     this._coop = Cc['@flock.com/singleton;1'].getService(Ci.flockISingleton)
  94.       .getSingleton('chrome://browser/content/flock/common/load-faves-coop.js')
  95.       .wrappedJSObject;
  96.  
  97.     var prefService = Cc['@mozilla.org/preferences-service;1']
  98.       .getService(Ci.nsIPrefBranch2);
  99.     prefService.addObserver(PREF_POLLER_BRANCH, this, false);
  100.  
  101.     this.observe(null, 'nsPref:changed', PREF_REFRESH_DELAY);
  102.     this.observe(null, 'nsPref:changed', PREF_REFRESH_TIMEOUT);
  103.     this.observe(null, 'nsPref:changed', PREF_DEFAULT_REFRESH_INTERVAL);
  104.     this.observe(null, 'nsPref:changed', PREF_MAX_CONCURRENT_REFRESHES);
  105.  
  106.     this._initializeQueue();
  107.     this._watchRDFEvents();
  108.  
  109.     this._profiler.profileEventEnd(evtID, "");
  110.   },
  111.   _shutdown: function PS__shutdown() {
  112.     var prefService = Cc['@mozilla.org/preferences-service;1']
  113.       .getService(Ci.nsIPrefBranch2);
  114.     prefService.removeObserver(PREF_POLLER_BRANCH, this);
  115.  
  116.     this._timer.cancel();
  117.     this._timer = null;
  118.   },
  119.  
  120.   _prefChanged: function PS__prefChanged(pref) {
  121.     var prefService = Cc['@mozilla.org/preferences-service;1']
  122.       .getService(Ci.nsIPrefService);
  123.     var prefBranch = prefService.getBranch(PREF_POLLER_BRANCH);
  124.  
  125.     switch (pref) {
  126.       case PREF_REFRESH_DELAY:
  127.         this._refreshDelay = prefBranch.getIntPref(pref);
  128.         break;
  129.  
  130.       case PREF_REFRESH_TIMEOUT:
  131.         this._refreshTimeout = prefBranch.getIntPref(pref);
  132.         break;
  133.  
  134.       case PREF_DEFAULT_REFRESH_INTERVAL:
  135.         this._defaultRefreshInterval = prefBranch.getIntPref(pref);
  136.         break;
  137.  
  138.       case PREF_MAX_CONCURRENT_REFRESHES:
  139.         this._maxConcurrentRefreshes = prefBranch.getIntPref(pref);
  140.         break;
  141.     }
  142.   },
  143.  
  144.   _watchRDFEvents: function PS__watchRDFEvents() {
  145.     var RDFS = Cc['@mozilla.org/rdf/rdf-service;1']
  146.       .getService(Ci.nsIRDFService);
  147.     var nextRefresh = RDFS.GetResource('http://flock.com/rdf#nextRefresh');
  148.     var isPollable = RDFS.GetResource('http://flock.com/rdf#isPollable');
  149.  
  150.     var faves = Cc['@mozilla.org/rdf/datasource;1?name=flock-favorites']
  151.       .getService(Ci.flockIRDFObservable);
  152.     faves.addArcObserver(Ci.flockIRDFObserver.TYPE_ALL, null, nextRefresh, null,
  153.                          this);
  154.     faves.addArcObserver(Ci.flockIRDFObserver.TYPE_ALL, null, isPollable, null,
  155.                          this);
  156.   },
  157.   rdfChanged: function PS_rdfChanged(ds, type, rsrc, pred, obj, oldObj) {
  158.     var pollable = this._coop.get_from_resource(rsrc);
  159.  
  160.     if (pollable && pollable.isPollable) {
  161.       if (pollable.nextRefresh)
  162.         this._addToQueue(pollable);
  163.       else
  164.         pollable.nextRefresh = new Date();
  165.     } else {
  166.       rsrc.QueryInterface(Ci.nsIRDFResource);
  167.       this._removeFromQueue(rsrc.ValueUTF8);
  168.     }
  169.   },
  170.  
  171.   _initializeQueue: function PS__initializeQueue() {
  172.     var queue = [];
  173.     var dates = {};
  174.  
  175.     var RDFS = Cc['@mozilla.org/rdf/rdf-service;1']
  176.       .getService(Ci.nsIRDFService);
  177.     var isPollable = RDFS.GetResource('http://flock.com/rdf#isPollable');
  178.  
  179.     var faves = Cc['@mozilla.org/rdf/datasource;1?name=flock-favorites']
  180.       .getService(Ci.nsIRDFDataSource);
  181.  
  182.     var pollables = faves.GetSources(isPollable, RDFS.GetLiteral('true'), true);
  183.     while (pollables.hasMoreElements()) {
  184.       var pollable = this._coop.get_from_resource(pollables.getNext());
  185.  
  186.       var urn = pollable.id();
  187.       queue.push(urn);
  188.  
  189.       if (!pollable.nextRefresh)
  190.         pollable.nextRefresh = new Date();
  191.  
  192.       dates[urn] = pollable.nextRefresh;
  193.     }
  194.  
  195.     function sorter(a, b) {
  196.       return dates[a] - dates[b];
  197.     }
  198.     queue.sort(sorter);
  199.  
  200.     this._queue = queue;
  201.     this._dates = dates;
  202.  
  203.     this._refreshing = {};
  204.     this._refreshOrder = [];
  205.  
  206.     this._lastRefresh = new Date(0);
  207.  
  208.     this._recalculateTimer();
  209.     this._logger.debug('queue initialized: ' + this._queue.toSource());
  210.   },
  211.  
  212.   _addToQueue: function PS__addToQueue(obj) {
  213.     var urn = obj.id();
  214.     var nextRefresh = obj.nextRefresh;
  215.  
  216.     var date = this._dates[urn];
  217.     if (date) {
  218.       if (date - nextRefresh == 0)
  219.         return;
  220.       else
  221.         this._queue.splice(this._queue.indexOf(urn), 1);
  222.     }
  223.  
  224.     this._dates[urn] = nextRefresh;
  225.  
  226.     for (var i = 0; i < this._queue.length; i++) {
  227.       var date = this._dates[this._queue[i]];
  228.       if (nextRefresh < date) {
  229.         this._queue.splice(i, 0, urn);
  230.         if (i == 0)
  231.           this._recalculateTimer();
  232.  
  233.         this._logger.debug('queue updated: ' + this._queue.toSource());
  234.         return;
  235.       }
  236.     }
  237.  
  238.     this._queue.push(urn);
  239.     if (this._queue.length == 1)
  240.       this._recalculateTimer();
  241.  
  242.     this._logger.debug('queue updated: ' + this._queue.toSource());
  243.   },
  244.  
  245.   _removeFromQueue: function PS__removeFromQueue(urn) {
  246.     var date = this._dates[urn];
  247.     if (!date)
  248.       return;
  249.  
  250.     delete this._dates[urn];
  251.  
  252.     var index = this._queue.indexOf(urn);
  253.     if (index == 0) {
  254.       this._queue.shift();
  255.       this._recalculateTimer();
  256.     } else {
  257.       this._queue.splice(index, 1);
  258.     }
  259.  
  260.     this._logger.debug('queue updated: ' + this._queue.toSource());
  261.   },
  262.  
  263.   _recalculateTimer: function PS__recalculateTimer() {
  264.     this._timer.cancel();
  265.  
  266.     if (this._queue.length) {
  267.       var date = this._dates[this._queue[0]];
  268.       var now = new Date();
  269.  
  270.       var interval = date > now ? date - now : 0;
  271.       interval = Math.min(interval, MAX_TIMER_INTERVAL);
  272.  
  273.       if (this._refreshOrder.length) {
  274.         var urn = this._refreshOrder[this._refreshOrder.length - 1];
  275.         var start = this._refreshing[urn].start;
  276.         var delay = (this._refreshDelay * 1000) - (now - start);
  277.         interval = Math.max(interval, delay);
  278.  
  279.         if (this._refreshOrder.length > this._maxConcurrentRefreshes - 1) {
  280.           urn = this._refreshOrder[0];
  281.           start = this._refreshing[urn].start;
  282.           delay = (this._refreshTimeout * 1000) - (now - start);
  283.           interval = Math.max(interval, delay);
  284.         }
  285.       } else {
  286.         var delay = (this._refreshDelay * 1000) - (now - this._lastRefresh);
  287.         interval = Math.max(interval, delay);
  288.       }
  289.  
  290.       this._logger.debug('next refresh: ' + interval / 1000);
  291.       this._timer.initWithCallback(this, interval, Ci.nsITimer.TYPE_ONE_SHOT);
  292.     }
  293.   },
  294.  
  295.   _finishedRefresh: function PS__finishedRefresh(urn) {
  296.     var index = this._refreshOrder.indexOf(urn);
  297.     if (index == -1)
  298.       return;
  299.  
  300.     var refreshInfo = this._refreshing[urn]
  301.     refreshInfo.timer.cancel();
  302.  
  303.     delete this._refreshing[urn];
  304.     this._refreshOrder.splice(index, 1);
  305.  
  306.     var obj = this._coop.get(urn);
  307.     if (!obj)
  308.       return;
  309.  
  310.     var now = new Date();
  311.     if (obj.nextRefresh < now) {
  312.       var refreshInterval = obj.refreshInterval ? obj.refreshInterval
  313.                                                 : this._defaultRefreshInterval;
  314.  
  315.       obj.nextRefresh = new Date(now.getTime() + refreshInterval * 1000);
  316.     }
  317.  
  318.     this._recalculateTimer();
  319.  
  320.     var obs = getObserverService();
  321.     obs.notifyObservers(null, "refresh-myworld", null);
  322.   },
  323.   _refresh: function PS__refresh(obj) {
  324.     var urn = obj.id();
  325.     if (this._refreshing[urn])
  326.       return;
  327.  
  328.     var serviceId = obj.serviceId;
  329.     this._logger.debug('serviceId = ' + serviceId);
  330.  
  331.     var service = null;
  332.     if (serviceId && Cc[serviceId]) {
  333.       try {
  334.         service = Cc[serviceId].getService(Ci.flockIPollingService);
  335.       }
  336.       catch (e) {
  337.         this._logger.error('Problem getting "' + serviceId + '" as a ' +
  338.                            'flockIPollingService, while trying to refresh ' + 
  339.                            urn);
  340.       }
  341.     }
  342.  
  343.     if (service) {
  344.       this._logger.info('Refreshing ' + urn);
  345.       try {
  346.         var now = new Date();
  347.  
  348.         var listener = new RefreshListener(this, urn, serviceId);
  349.         service.refresh(urn, listener);
  350.  
  351.         var timer = Cc['@mozilla.org/timer;1'].createInstance(Ci.nsITimer);
  352.         timer.initWithCallback(listener, this._refreshTimeout * 1000,
  353.                                Ci.nsITimer.TYPE_ONE_SHOT);
  354.  
  355.         this._refreshing[urn] = { start: now, timer: timer };
  356.         this._refreshOrder.push(urn);
  357.  
  358.         this._lastRefresh = now;
  359.       }
  360.       catch (e) {
  361.         this._logger.error('Exception while ' + serviceId + ' was refreshing ' +
  362.                            'a stream: ' + e);
  363.       }
  364.     } else {
  365.       this._logger.error('Problem getting the service, while trying to ' +
  366.                          'refresh ' + urn);
  367.     }
  368.   },
  369.  
  370.   notify: function PS_notify(timer) {
  371.     var urn = this._queue[0];
  372.     var date = this._dates[urn];
  373.  
  374.     var now = new Date();
  375.     if (now < date) {
  376.       this._recalculateTimer();
  377.       return;
  378.     }
  379.  
  380.     this._queue.shift();  
  381.     delete this._dates[urn];
  382.  
  383.     var obj = this._coop.get(urn);
  384.     if (obj)
  385.       this._refresh(this._coop.get(urn));
  386.     else
  387.       this._logger.warn('trying to refresh nonexistent object: ' + urn);
  388.  
  389.     this._recalculateTimer();
  390.   },
  391.  
  392.   observe: function PS_observe(subject, topic, state) {
  393.     var obs = getObserverService();
  394.  
  395.     switch (topic) {
  396.       case 'flock-data-ready':
  397.         obs.removeObserver(this, 'flock-data-ready');
  398.         this._start();
  399.         break;
  400.  
  401.       case 'xpcom-shutdown':
  402.         obs.removeObserver(this, 'xpcom-shutdown');
  403.         this._shutdown();
  404.         break;
  405.  
  406.       case 'nsPref:changed':
  407.         this._prefChanged(state);
  408.         break;
  409.     }
  410.   },
  411.  
  412.   forceRefresh: function PS_forceRefresh(urn) {
  413.     var obj = this._coop.get(urn);
  414.     if (!obj)
  415.       throw 'URN ' + urn + ' does not exist'; 
  416.  
  417.     obj.nextRefresh = new Date(0);
  418.   },
  419.  
  420.   getInterfaces: function PS_getInterfaces(countRef) {
  421.     var interfaces = [Ci.flockIPollerService, Ci.flockIRDFObserver,
  422.                       Ci.nsITimerCallback, Ci.nsIObserver, Ci.nsIClassInfo,
  423.                       Ci.nsISupports];
  424.     countRef.value = interfaces.length;
  425.     return interfaces;
  426.   },
  427.   getHelperForLanguage: function PS_getHelperForLanguage(language) {
  428.     return null;
  429.   },
  430.   contractID: PS_CONTRACTID,
  431.   classDescription: PS_CLASSNAME,
  432.   classID: PS_CLASSID,
  433.   implementationLanguage: Ci.nsIProgrammingLanguage.JAVASCRIPT,
  434.   flags: Ci.nsIClassInfo.SINGLETON,
  435.  
  436.   QueryInterface: function PS_QueryInterface(iid) {
  437.     if (iid.equals(Ci.flockIPollerService) ||
  438.         iid.equals(Ci.flockIRDFObserver) ||
  439.         iid.equals(Ci.nsITimerCallback) ||
  440.         iid.equals(Ci.nsIObserver) ||
  441.         iid.equals(Ci.nsIClassInfo) ||
  442.         iid.equals(Ci.nsISupports))
  443.       return this;
  444.     throw Cr.NS_ERROR_NO_INTERFACE;
  445.   }
  446. }
  447.  
  448.  
  449. function GenericComponentFactory(ctor) {
  450.   this._ctor = ctor;
  451. }
  452.  
  453. GenericComponentFactory.prototype = {
  454.  
  455.   _ctor: null,
  456.  
  457.   // nsIFactory
  458.   createInstance: function(outer, iid) {
  459.     if (outer != null)
  460.       throw Cr.NS_ERROR_NO_AGGREGATION;
  461.     return (new this._ctor()).QueryInterface(iid);
  462.   },
  463.  
  464.   // nsISupports
  465.   QueryInterface: function(iid) {
  466.     if (iid.equals(Ci.nsIFactory) ||
  467.         iid.equals(Ci.nsISupports))
  468.       return this;
  469.     throw Cr.NS_ERROR_NO_INTERFACE;
  470.   },
  471. };
  472.  
  473. var Module = {
  474.   QueryInterface: function(iid) {
  475.     if (iid.equals(Ci.nsIModule) ||
  476.         iid.equals(Ci.nsISupports))
  477.       return this;
  478.  
  479.     throw Cr.NS_ERROR_NO_INTERFACE;
  480.   },
  481.  
  482.   getClassObject: function(cm, cid, iid) {
  483.     if (!iid.equals(Ci.nsIFactory))
  484.       throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  485.  
  486.     if (cid.equals(PS_CLASSID))
  487.       return new GenericComponentFactory(PollerService);
  488.  
  489.     throw Cr.NS_ERROR_NO_INTERFACE;
  490.   },
  491.  
  492.   registerSelf: function(cm, file, location, type) {
  493.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  494.     cr.registerFactoryLocation(PS_CLASSID, PS_CLASSNAME, PS_CONTRACTID,
  495.                                file, location, type);
  496.  
  497.     var catman = Cc['@mozilla.org/categorymanager;1']
  498.       .getService(Ci.nsICategoryManager);
  499.     catman.addCategoryEntry('flock-startup', PS_CLASSNAME,
  500.                             'service,' + PS_CONTRACTID,
  501.                             true, true);
  502.   },
  503.  
  504.   unregisterSelf: function(cm, location, type) {
  505.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  506.     cr.unregisterFactoryLocation(PS_CLASSID, location);
  507.   },
  508.  
  509.   canUnload: function(cm) {
  510.     return true;
  511.   },
  512. };
  513.  
  514. function NSGetModule(compMgr, fileSpec)
  515. {
  516.   return Module;
  517. }
  518.